home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / art_ui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  8.3 KB  |  340 lines
  1. /*****************************************************************************
  2.   FILE           : art_ui.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : SNNS-Kernel-User-Interface for ART Networks
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Kai-Uwe Herrmann
  10.   DATE           : 17.05.92
  11.  
  12.   CHANGED BY     : Sven Doering
  13.   IDENTIFICATION : @(#)art_ui.c    1.8 3/15/94
  14.   SCCS VERSION   : 1.8
  15.   LAST CHANGE    : 3/15/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20. #include "kr_typ.h"     /* Global Definitions for User Interface */
  21. #include "kr_ui.h"      /* User Interface - Function Prototypes */
  22.  
  23. #include "kr_const.h"   /* Global constants for kernel */
  24.  
  25. #include "glob_typ.h"   /* Global Definitions for User Interface */
  26. #include "kernel.h"
  27.  
  28. #include "art_typ.h"    /* ART Global Definitions */
  29. #include "kr_art.h"     /* ART Kernel Function Prototypes */
  30. #include "kr_art1.h"
  31. #include "kr_art2.h"
  32. #include "kr_amap.h"
  33. #include "krart_df.h"   /* ART definitions and Macros */
  34. #include "art_ui.h"     /* ART User Interface Function Prototypes */
  35.  
  36.  
  37.  
  38. /* funcname: artui_GetClassifiedStatus ()
  39.    Purpose : Returns the classification status of the actual network
  40.    in-Par  : none
  41.    out-Par : status :   Possible results are:   ART_NO_CLASSIFICATION
  42.                                                 ART_CLASSIFIED
  43.                                                 ART_NOT_CLASSIFIABLE
  44.                                                 ART_DONT_KNOW
  45.    ret_val : krui_err:  Returns an error if no Units defined
  46. */
  47. krui_err artui_getClassifiedStatus (art_cl_status *status)
  48. {
  49.    krui_err        ret_code           = KRERR_NO_ERROR;
  50.  
  51.    *status = ART_NO_CLASSIFICATION;
  52.  
  53.    if (krui_getNoOfUnits() == 0) {
  54.       ret_code = KRERR_NO_UNITS;
  55.       return (ret_code);
  56.    } /*if*/
  57.  
  58.    /* Check if network has been initialized or update- or learning function
  59.       has been applied to it. If not, we can not know, which type of ART
  60.       network this is, so we return, that there has been no classification.
  61.    */
  62.    if (NetModified) {
  63.       return (ret_code);
  64.    } /*if*/
  65.  
  66.    switch (TopoSortID) {
  67.    case ART1_TOPO_TYPE:
  68.       if (ART1_CLASSIFIED) {
  69.          *status = ART_CLASSIFIED;
  70.       } else {
  71.          if (ART1_NOT_CLASSIFIABLE) {
  72.             *status = ART_NOT_CLASSIFIABLE;
  73.          } /*if*/
  74.       } /*if*/
  75.       break;
  76.    case ART2_TOPO_TYPE:
  77.       if (ART2_CLASSIFIED) {
  78.          *status = ART_CLASSIFIED;
  79.       } else {
  80.          if (ART2_NOT_CLASSIFIABLE) {
  81.            *status = ART_NOT_CLASSIFIABLE;
  82.          } /*if*/
  83.       } /*if*/
  84.    case ARTMAP_TOPO_TYPE:
  85.       if (ARTMAP_CLASSIFIED) {
  86.          if (kram_AllMapUnitsActive()) {
  87.             *status = ART_DONT_KNOW;
  88.          } else {
  89.             *status = ART_CLASSIFIED;
  90.          } /*if*/
  91.       } else {
  92.          if (ARTMAP_NOT_CLASSIFIABLE) {
  93.             *status = ART_NOT_CLASSIFIABLE;
  94.          } /*if*/
  95.       } /*if*/
  96.    default:
  97.       break;
  98.    } /* switch */
  99.  
  100.    return (ret_code);
  101. } /* artui_getClassifiedStatus () */
  102.  
  103.  
  104.  
  105.  
  106. /* funcname: artui_getClassNo ()
  107.    Purpose : Returns the index of the F2-winner-unit
  108.    in-par  : none
  109.    out-par : class_no :  If unit_no is negative, then no winning unit exists.
  110.    ret-val : krui_err :  Returns an error if no Units defined.
  111. */
  112. krui_err artui_getClassNo (int *class_no)
  113. {
  114.    krui_err       ret_code        = KRERR_NO_ERROR;
  115.  
  116.    *class_no = -1;
  117.  
  118.    if (krui_getNoOfUnits () == 0) {
  119.       ret_code = KRERR_NO_UNITS;
  120.       return (ret_code);
  121.    } /*if*/
  122.  
  123.    /* Check if network has been initialized or update- or learning function
  124.       has been applied to it. If not, we can not know, which type of ART
  125.       network this is, so we return, that there has been no classification.
  126.       If there is a adequate TopoSortID, then we get the no. of the class,
  127.       if there has been a classification.
  128.    */
  129.  
  130.    if (NetModified) {
  131.       return (ret_code);
  132.    } /*if*/
  133.  
  134.    switch (TopoSortID) {
  135.    case ART1_TOPO_TYPE:
  136.       if (ART1_CLASSIFIED) {
  137.          *class_no = kra1_getClassNo ();
  138.       } /*if*/
  139.       break;
  140.    case ART2_TOPO_TYPE:
  141.       if (ART2_CLASSIFIED) {
  142.          *class_no = kra2_getClassNo ();
  143.       } /*if*/
  144.    case ARTMAP_TOPO_TYPE:
  145.       if (ARTMAP_CLASSIFIED && (!kram_AllMapUnitsActive())) {
  146.          *class_no = kram_getClassNo ();
  147.       } /*if*/
  148.    default:
  149.       break;
  150.    } /* switch */
  151.  
  152.    return (ret_code);
  153. } /* artui_getClassNo () */
  154.  
  155.  
  156.  
  157. /* funcname: artui_getN ()
  158.    Purpose : Returns the number of F1-units in an ART1 or ART2 network
  159.    in-par  : none
  160.    out-par : N : number of F1-Units (-1 is returned if not topologically sorted)
  161.    ret-val : krui_err:  Returns an error if no Units defined.
  162. */
  163. krui_err artui_getN (int *N)
  164. {
  165.    krui_err         ret_code = KRERR_NO_ERROR;
  166.  
  167.    *N = -1;
  168.  
  169.    if (krui_getNoOfUnits() == 0) {
  170.       ret_code = KRERR_NO_UNITS;
  171.       return (ret_code);
  172.    } /*if*/
  173.  
  174.    if (NetModified) {
  175.       return (ret_code);
  176.    } /*if*/
  177.  
  178.    if ((TopoSortID == ART1_TOPO_TYPE) || (TopoSortID == ART2_TOPO_TYPE)) {
  179.       *N = NoOfInputUnits;
  180.    } /*if*/
  181.  
  182.    return (ret_code);
  183. } /* artui_getN () */
  184.  
  185.  
  186. /* funcname: artui_getM ()
  187.    Purpose : Returns the number of F2-units in an ART1 or ART2 network
  188.    in-par  : none
  189.    out-par : M : number of F2-Units (-1 is returned if not topologically sorted)
  190.    ret-val : krui_err:  Returns an error if no Units defined.
  191. */
  192. krui_err artui_getM (int *M)
  193. {
  194.    krui_err         ret_code = KRERR_NO_ERROR;
  195.  
  196.    *M = -1;
  197.  
  198.    if (krui_getNoOfUnits() == 0) {
  199.       ret_code = KRERR_NO_UNITS;
  200.       return (ret_code);
  201.    } /*if*/
  202.  
  203.    if (NetModified) {
  204.       return (ret_code);
  205.    } /*if*/
  206.  
  207.    switch (TopoSortID) {
  208.    case ART1_TOPO_TYPE:
  209.       *M = Art1_NoOfRecUnits;
  210.       break;
  211.    case ART2_TOPO_TYPE:
  212.       *M = Art2_NoOfRecUnits;
  213.       break;
  214.    } /*switch*/
  215.  
  216.    return (ret_code);
  217. } /* artui_getM () */
  218.  
  219.  
  220.  
  221. /* funcname: artui_getNa ()
  222.    Purpose : Returns the number of F1a-units in an ARTMAP network
  223.    in-par  : none
  224.    out-par : Na: number of F1a-Units (-1 is returned if not topologically sorted)
  225.    ret-val : krui_err:  Returns an error if no Units defined.
  226. */
  227. krui_err artui_getNa (int *Na)
  228. {
  229.    krui_err         ret_code = KRERR_NO_ERROR;
  230.  
  231.    *Na = -1;
  232.  
  233.    if (krui_getNoOfUnits() == 0) {
  234.       ret_code = KRERR_NO_UNITS;
  235.       return (ret_code);
  236.    } /*if*/
  237.  
  238.    if (NetModified) {
  239.       return (ret_code);
  240.    } /*if*/
  241.  
  242.    if (TopoSortID == ARTMAP_TOPO_TYPE) {
  243.       *Na = ArtMap_NoOfInpUnits_a;
  244.    } /*if*/
  245.  
  246.    return (ret_code);
  247. } /* artui_getNa () */
  248.  
  249.  
  250.  
  251.  
  252. /* funcname: artui_getNb ()
  253.    Purpose : Returns the number of F1b-units in an ARTMAP network
  254.    in-par  : none
  255.    out-par : Nb: number of F1b-Units (-1 is returned if not topologically sorted)
  256.    ret-val : krui_err:  Returns an error if no Units defined.
  257. */
  258. krui_err artui_getNb (int *Nb)
  259. {
  260.    krui_err         ret_code = KRERR_NO_ERROR;
  261.  
  262.    *Nb = -1;
  263.  
  264.    if (krui_getNoOfUnits() == 0) {
  265.       ret_code = KRERR_NO_UNITS;
  266.       return (ret_code);
  267.    } /*if*/
  268.  
  269.    if (NetModified) {
  270.       return (ret_code);
  271.    } /*if*/
  272.  
  273.    if (TopoSortID == ARTMAP_TOPO_TYPE) {
  274.       *Nb = ArtMap_NoOfInpUnits_b;
  275.    } /*if*/
  276.  
  277.    return (ret_code);
  278. } /* artui_getNb () */
  279.  
  280.  
  281.  
  282.  
  283. /* funcname: artui_getMa ()
  284.    Purpose : Returns the number of F2a-units in an ARTMAP network
  285.    in-par  : none
  286.    out-par : Ma: number of F2a-Units (-1 is returned if not topologically sorted)
  287.    ret-val : krui_err:  Returns an error if no Units defined.
  288. */
  289. krui_err artui_getMa (int *Ma)
  290. {
  291.    krui_err         ret_code = KRERR_NO_ERROR;
  292.  
  293.    *Ma = -1;
  294.  
  295.    if (krui_getNoOfUnits() == 0) {
  296.       ret_code = KRERR_NO_UNITS;
  297.       return (ret_code);
  298.    } /*if*/
  299.  
  300.    if (NetModified) {
  301.       return (ret_code);
  302.    } /*if*/
  303.  
  304.    if (TopoSortID == ARTMAP_TOPO_TYPE) {
  305.       *Ma = ArtMap_NoOfRecUnits_a;
  306.    } /*if*/
  307.  
  308.    return (ret_code);
  309. } /* artui_getMa () */
  310.  
  311.  
  312.  
  313. /* funcname: artui_getMb ()
  314.    Purpose : Returns the number of F2b-units in an ARTMAP network
  315.    in-par  : none
  316.    out-par : Mb: number of F2b-Units (-1 is returned if not topologically sorted)
  317.    ret-val : krui_err:  Returns an error if no Units defined.
  318. */
  319. krui_err artui_getMb (int *Mb)
  320. {
  321.    krui_err         ret_code = KRERR_NO_ERROR;
  322.  
  323.    *Mb = -1;
  324.  
  325.    if (krui_getNoOfUnits() == 0) {
  326.       ret_code = KRERR_NO_UNITS;
  327.       return (ret_code);
  328.    } /*if*/
  329.  
  330.    if (NetModified) {
  331.       return (ret_code);
  332.    } /*if*/
  333.  
  334.    if (TopoSortID == ARTMAP_TOPO_TYPE) {
  335.       *Mb = ArtMap_NoOfRecUnits_b;
  336.    } /*if*/
  337.  
  338.    return (ret_code);
  339. } /* artui_getMb () */
  340.